package xstring

import (
	"bytes"
	"encoding/json"
	"errors"
	"io"
	"iter"
	"unicode"
	"unicode/utf8"
	"unsafe"

	"slices"

	"gitee.com/gousing/helper/internal"
	"golang.org/x/text/cases"
	"golang.org/x/text/language"
	"golang.org/x/text/width"
)

// Buffer 支持常用字符串/字节辅助工具的 String Buffer
type Buffer struct {
	buf        []byte
	readOffset int  // 辅助完成 io.Reader 接口的实现
	onlyASCII  int8 // 是否仅包含ASCII字符  -1 待检测, 1 是, 0 否
}

var _ io.ByteWriter = (*Buffer)(nil)
var _ io.StringWriter = (*Buffer)(nil)
var _ io.Writer = (*Buffer)(nil)
var _ io.WriterAt = (*Buffer)(nil)
var _ io.WriterTo = (*Buffer)(nil)
var _ io.Reader = (*Buffer)(nil)
var _ io.ReaderAt = (*Buffer)(nil)
var _ json.Marshaler = (*Buffer)(nil)
var _ json.Unmarshaler = (*Buffer)(nil)

// NewBuffer returns a String Buffer.
//   - defaultCap: initial capacity of the buffer.
//   - defaultCap: 预估的字符串字节长度, 初始化内存分配(减少CAP自动扩容带来的内存分配)
func NewBuffer(defaultCap ...int) *Buffer {
	if len(defaultCap) > 0 && defaultCap[0] > 0 {
		return &Buffer{buf: make([]byte, 0, defaultCap[0]), readOffset: 0, onlyASCII: 1}
	}
	return &Buffer{buf: make([]byte, 0), readOffset: 0, onlyASCII: 1}
}

// bytesOnlyASCII 检查给定的字节切片是否仅包含 ASCII 字符（0x00 到 0x7F）。
//   - 如果输入为空切片或 nil，返回 true。
//   - copy xbyte.OnlyASCII
func bytesOnlyASCII(data []byte) bool {
	if len(data) == 0 {
		return true
	}
	for i := range data {
		if data[i] > 0x7F {
			return false
		}
	}
	return true
}

// Grow 增加/扩容内存分配(减少CAP自动扩容带来的内存分配)
// grows b's capacity, if necessary, to guarantee space for
// another n bytes. After Grow(n), at least n bytes can be written to b
// without another allocation. If n is negative, Grow panics.
func (b *Buffer) Grow(n int) {
	if n < 0 {
		panic("Stringer Buffer.Grow(n): negative n")
	}
	if n == 0 {
		return // 无需扩容
	}
	if b.buf == nil {
		b.buf = make([]byte, 0, n)
		return // 初始化
	}
	// 扩容
	bLen := len(b.buf)
	if cap(b.buf)-bLen < n {
		buf := make([]byte, bLen, bLen+n)
		copy(buf, b.buf)
		b.buf = buf
	}
}

// Len 返回 Stringer Buffer 的字节长度
func (b *Buffer) Len() int {
	return len(b.buf)
}

// Cap 返回 Stringer Buffer 的字节容量
func (b *Buffer) Cap() int {
	return cap(b.buf)
}

// Reset 重置并清空 Stringer Buffer
func (b *Buffer) Reset() {
	b.buf = nil
	b.readOffset = 0
	b.onlyASCII = 1
}
func (b *Buffer) OnlyASCII() bool {
	if b.onlyASCII == -1 {
		if bytesOnlyASCII(b.buf) {
			b.onlyASCII = 1
		} else {
			b.onlyASCII = 0
		}
	}
	return b.onlyASCII == 1
}

// Write 实现 io.Writer 接口, 将数据写入到 Stringer Buffer
func (b *Buffer) Write(val []byte) (int, error) {
	if len(val) == 0 {
		return 0, nil
	}
	n := len(b.buf)
	b.buf = append(b.buf, val...)
	// 更新 onlyASCII 状态
	// -1 表示状态未知，需要重新计算
	b.onlyASCII = -1
	return len(b.buf) - n, nil
}

// WriteString 实现 io.StringWriter 接口, 字符串写入到 Stringer Buffer
func (b *Buffer) WriteString(s string) (int, error) {
	if len(s) == 0 {
		return 0, nil
	}
	val := internal.StringToBytes(s)
	n := len(b.buf)
	b.buf = append(b.buf, val...)
	// 更新 onlyASCII 状态
	// -1 表示状态未知，需要重新计算
	b.onlyASCII = -1
	return len(b.buf) - n, nil
}

// WriteByte 实现 io.ByteWriter 接口, 单个字节写入到 Stringer Buffer
func (b *Buffer) WriteByte(c byte) error {
	b.buf = append(b.buf, c)
	// 更新 onlyASCII 状态
	// -1 表示状态未知，需要重新计算
	b.onlyASCII = -1
	return nil
}

// WriteRune 单个Rune到Stringer Buffer
func (b *Buffer) WriteRune(r rune) (int, error) {
	n := len(b.buf)
	b.buf = utf8.AppendRune(b.buf, r)
	// 更新 onlyASCII 状态
	// -1 表示状态未知，需要重新计算
	b.onlyASCII = -1
	return len(b.buf) - n, nil
}

// WriteAt 实现io.WriterAt接口的WriteAt方法，将指定字节切片中的数据写入到Stringer Buffer指定偏移量off的位置(并替换掉旧数据)
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
func (b *Buffer) WriteAt(p []byte, off int64) (n int, err error) {
	if off < 0 || off > int64(len(b.buf)) {
		return 0, errors.New("stringer Buffer.WriteAt: invalid offset")
	}
	available := int64(len(b.buf)) - off
	if available < int64(len(p)) {
		// Stringer Buffer 填充位置
		b.buf = append(b.buf, make([]byte, int64(len(p))-available)...)
	}
	copy(b.buf[off:], p)
	n = len(p)
	b.onlyASCII = -1
	return
}

// WriteFrom 从 io.Reader 读取数据写入到 Stringer Buffer
func (b *Buffer) WriteFrom(r io.Reader) (n int64, err error) {
	if r == nil {
		return
	}
	const chunkSize = 1024
	buffer := make([]byte, chunkSize)
	for {
		m, err := r.Read(buffer)
		if m > 0 {
			b.buf = append(b.buf, buffer[0:m]...)
			n += int64(m)
		}
		if err == io.EOF {
			break
		} else if err != nil {
			b.onlyASCII = -1
			return n, err
		}
	}
	b.onlyASCII = -1
	return n, nil
}

// WriteTo 实现 io.WriterTo 接口，将 Stringer Buffer 数据写入到指定的io.Writer
func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) {
	if len(b.buf) == 0 || w == nil {
		return
	}
	var nn int
	nn, err = w.Write(b.buf)
	return int64(nn), err
}

// Read 实现 io.Reader 接口, 读取 Stringer Buffer 数据写入到指定切片
func (b *Buffer) Read(p []byte) (n int, err error) {
	if len(p) == 0 {
		return 0, nil
	}
	if len(b.buf) == 0 {
		return 0, io.EOF
	}
	// 一次性读取全部数据
	if len(p) > len(b.buf) {
		n = copy(p, b.buf)
		return n, nil
	}
	// 已读取完
	if b.readOffset >= len(b.buf) {
		b.readOffset = 0
		return 0, io.EOF
	}
	// 读取数据
	n = copy(p, b.buf[b.readOffset:])
	b.readOffset += n
	return n, nil
}

// ReadAt 实现io.ReaderAt接口的ReadAt方法, 按偏移量读取 Stringer Buffer 数据写入到指定切片
//   - 注意指定切片len(p)容量必须大于0, 否则无法读取到数据
func (r *Buffer) ReadAt(p []byte, off int64) (n int, err error) {
	if off < 0 || off >= int64(len(r.buf)) {
		return 0, io.EOF
	}
	available := int64(len(r.buf)) - off
	if available <= 0 {
		return 0, io.EOF
	}
	n = copy(p, r.buf[off:])
	if n < len(p) {
		return n, io.ErrUnexpectedEOF
	}
	return n, nil
}

// SubString 按字节方式截取字符串的一部分(支持多语言字符串)
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - start：起始下标，>=0 时从头部开始截取, 负数从从尾部开始，最后一个为-1
//   - length：截取长度，<0 时表示截取到末尾
//   - 返回值：截取的字符串, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) SubString(start, length int) string {
	bytesTotal := len(b.buf)
	if bytesTotal == 0 || length == 0 {
		return ""
	}
	// 允许从尾部开始重新计算开始位置
	if start < 0 {
		start = bytesTotal + start
		if start < 0 {
			return ""
		}
	}
	if start > bytesTotal {
		return ""
	}
	// 处理负长度，表示截取到末尾
	if length < 0 {
		length = bytesTotal - start
		if length <= 0 {
			return ""
		}
	}
	end := min(start+length, bytesTotal)
	if start == end {
		return ""
	}
	if b.OnlyASCII() {
		return internal.BytesToString(b.buf[start:end])
	}

	var (
		data = b.buf[start:end]
		buf  = bytes.NewBuffer(make([]byte, 0, end-start))
	)
	for len(data) > 0 {
		r, size := utf8.DecodeRune(data)
		if r == utf8.RuneError || size == 0 {
			if size+1 >= len(data) {
				break
			}
			data = data[size+1:]
			continue
		}
		buf.WriteRune(r)
		if size >= len(data) {
			break
		}
		data = data[size:]
	}
	return buf.String()
}

// SubBytes 按字节方式截取字节切片的一部分(支持多语言字符串)
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - start：起始下标，>=0 时从头部开始截取, 负数从从尾部开始，最后一个为-1
//   - length：截取长度，<0 时表示截取到末尾
//   - 返回值：截取的字节切片, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) SubBytes(start, length int) []byte {
	bytesTotal := len(b.buf)
	if bytesTotal == 0 || length == 0 {
		return []byte{}
	}
	// 允许从尾部开始重新计算开始位置
	if start < 0 {
		start = bytesTotal + start
		if start < 0 {
			return []byte{}
		}
	}
	if start > bytesTotal {
		return []byte{}
	}
	// 处理负长度，表示截取到末尾
	if length < 0 {
		length = bytesTotal - start
		if length <= 0 {
			return []byte{}
		}
	}
	end := min(start+length, bytesTotal)
	if start == end {
		return []byte{}
	}
	if b.OnlyASCII() {
		return b.buf[start:end]
	}

	var (
		data = b.buf[start:end]
		buf  = bytes.NewBuffer(make([]byte, 0, end-start))
	)
	// 预分配字符串最大长度
	buf.Grow(end - start)
	for len(data) > 0 {
		r, size := utf8.DecodeRune(data)
		if r == utf8.RuneError || size == 0 {
			if size+1 >= len(data) {
				break
			}
			data = data[size+1:]
			continue
		}
		buf.WriteRune(r)
		if size >= len(data) {
			break
		}
		data = data[size:]
	}
	return buf.Bytes()
}

// PosString 按字符串索引方式  String[start:end] 截取部分字符串并返回
//   - start is offset, like String[start:end]
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - 返回值：截取的字符串, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) PosString(start, end int) string {
	if start > end || start < 0 || end > len(b.buf) {
		panic("Stringer Buffer.PosString: start > end || start < 0 || end > len(b.buf)")
	}
	if len(b.buf) == 0 || start == end {
		return ""
	}
	return b.SubString(start, end-start)
}

// PosStringStart 按字符串索引方式  String[start:] 截取部分字符串并返回
//   - start is offset, like String[start:]
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - 返回值：截取的字符串, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) PosStringStart(start int) string {
	if start < 0 || start > len(b.buf)-1 {
		panic("Stringer Buffer.PosStringStart: start < 0 || start > len(b.buf)-1")
	}
	if len(b.buf) == 0 {
		return ""
	}
	return b.SubString(start, -1)
}

// PosStringEnd 按字符串索引方式  String[:end] 截取部分字符串并返回
//   - end is offset, like String[:end]
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - 返回值：截取的字符串, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) PosStringEnd(end int) string {
	if end < 0 || end > len(b.buf) {
		panic("Stringer Buffer.PosStringEnd: end < 0 || end > len(b.buf)")
	}
	if len(b.buf) == 0 || end == 0 {
		return ""
	}
	return b.SubString(0, end)
}

// PosBytes 按Byte索引方式 Bytes[start:end] 截取部分字节并返回
//   - start and end is offset, like Bytes[start:end]
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - 返回值：截取的字节切片, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) PosBytes(start, end int) []byte {
	if start > end || start < 0 || end > len(b.buf) {
		panic("Stringer Buffer.PosBytes: start > end || start < 0 || end > len(b.buf)")
	}
	if end == start || len(b.buf) == 0 {
		return []byte{}
	}
	return b.SubBytes(start, end-start)
}

// PosBytesStart 按Byte索引方式 Bytes[start:] 截取部分字节并返回
//   - start is offset, like Bytes[start:]
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - 返回值：截取的字节切片, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) PosBytesStart(start int) []byte {
	if start < 0 || start > len(b.buf)-1 {
		panic("Stringer Buffer.PosBytesStart: start < 0 || start > len(b.buf)-1")
	}
	if len(b.buf) == 0 {
		return []byte{}
	}
	return b.SubBytes(start, -1)
}

// PosBytesEnd 按Byte索引方式 Bytes[:end] 截取部分字节并返回
//   - end is exclusive, like Bytes[:end]
//   - 注意: 对于ASCII字符串, 1个字符占1个字节, 一个UTF-8字符(Rune)可能占2个字节，3个字节，甚至4个字节
//   - 返回值：截取的字节切片, 如字节区间包含不完整的字符，将做丢弃处理
func (b *Buffer) PosBytesEnd(end int) []byte {
	if end < 0 || end > len(b.buf) {
		panic("Stringer Buffer.PosBytesEnd: end < 0 || end > len(b.buf)")
	}
	if len(b.buf) == 0 {
		return []byte{}
	}
	return b.SubBytes(0, end)
}

// Equal 判断两个Stringer Buffer是否相等
func (b *Buffer) Equal(other *Buffer) bool {
	if other == nil || b.Len() != other.Len() {
		return false
	}
	for i := range b.buf {
		if b.buf[i] != other.buf[i] {
			return false
		}
	}
	return true
}

// HasPrefix 判断Stringer Buffer 是否以指定前缀字节切片开头
func (b *Buffer) HasPrefix(prefix []byte) bool {
	sl := len(prefix)
	bl := len(b.buf)
	if sl == 0 || bl == 0 || sl > bl {
		return false
	}
	for i := range sl {
		if prefix[i] != b.buf[i] {
			return false
		}
	}
	return true
}

// HasPrefixString 判断Stringer Buffer 是否以指定前缀字符串开头
func (b *Buffer) HasPrefixString(prefix string) bool {
	return b.HasPrefix(ToBytes(prefix))
}

// HasSuffix 判断Stringer Buffer 是否以指定后缀字节切片结尾
func (b *Buffer) HasSuffix(suffix []byte) bool {
	sl := len(suffix)
	bl := len(b.buf)
	if sl == 0 || bl == 0 || sl > bl {
		return false
	}
	for i, j := sl-1, bl-1; i >= 0; {
		if suffix[i] != b.buf[j] {
			return false
		}
		i--
		j--
	}
	return true
}

// HasSuffixString 判断Stringer Buffer 是否以指定后缀字符串结尾
func (b *Buffer) HasSuffixString(suffix string) bool {
	return b.HasSuffix(ToBytes(suffix))
}

// Contains 判断Stringer Buffer 是否包含指定子字节切片subBytes
//   - 注意: subBytes 为空返回 true
func (b *Buffer) Contains(subBytes []byte) bool {
	return b.Index(subBytes) != -1
}

// ContainsString 判断Stringer Buffer 是否包含指定字符串subString
//   - 注意: subString 为空返回 true
func (b *Buffer) ContainsString(subString string) bool {
	return b.Index(ToBytes(subString)) != -1
}

// ContainsSome 判断Stringer Buffer 是否包含指定字节切片中的任意一个
//   - 注意: some 为空返回 true
func (b *Buffer) ContainsSome(someBytes ...[]byte) bool {
	if len(someBytes) == 0 {
		return true
	}
	if len(b.buf) == 0 {
		return false
	}
	for _, v := range someBytes {
		if b.Index(v) != -1 {
			return true
		}
	}
	return false
}

// ContainsSomeString 判断Stringer Buffer 是否包含指定字符串someString中的任意一个
//   - 注意: some 为空返回 true
func (b *Buffer) ContainsSomeString(someString ...string) bool {
	if len(someString) == 0 {
		return true
	}
	if len(b.buf) == 0 {
		return false
	}
	for _, v := range someString {
		if b.Index(ToBytes(v)) != -1 {
			return true
		}
	}
	return false
}

// ContainsByte 判断Stringer Buffer 是否包含指定的字节Byte
//   - 注意: byte 为空返回 true
func (b *Buffer) ContainsByte(v byte) bool {
	return b.IndexByte(v) != -1
}

// ContainsRune 判断Stringer Buffer 是否包含指定的字符Rune
//   - 注意: rune 为空返回 true
func (b *Buffer) ContainsRune(v rune) bool {
	return b.IndexRune(v) != -1
}

// Index 按字节遍历返回指定字节切片[]byte在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
//   - 注意: subBytes 为空返回 0
func (b *Buffer) Index(subBytes []byte) int {
	if len(subBytes) == 0 {
		return 0
	}
	if len(b.buf) == 0 {
		return -1
	}
	if len(subBytes) == 1 {
		return b.IndexByte(subBytes[0])
	}
	return bytes.Index(b.buf, subBytes)
}

// IndexString 返回指定字符串subString在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
//   - 注意: subString 为空返回 0
func (b *Buffer) IndexString(subString string) int {
	if len(subString) == 0 {
		return 0
	}
	if len(b.buf) == 0 {
		return -1
	}
	subBytes := ToBytes(subString)
	if len(subBytes) == 1 {
		return b.IndexByte(subBytes[0])
	}
	return bytes.Index(b.buf, subBytes)
}

// IndexSome 返回指定字节切片中的任意一个someBytes在 Stringer Buffer 中的字节POS位置
//   - 注意: someString 为空返回 0
func (b *Buffer) IndexSome(someBytes ...[]byte) int {
	if len(someBytes) == 0 {
		return 0
	}
	if len(b.buf) == 0 {
		return -1
	}
	for _, v := range someBytes {
		if p := b.Index(v); p != -1 {
			return p
		}
	}
	return -1
}

// IndexSomeString 返回指定字符串中的任意一个someString在 Stringer Buffer 中的字节POS位置
//   - 注意: someString 为空返回 0
func (b *Buffer) IndexSomeString(someString ...string) int {
	if len(someString) == 0 {
		return 0
	}
	if len(b.buf) == 0 {
		return -1
	}
	for _, v := range someString {
		if p := b.Index(ToBytes(v)); p != -1 {
			return p
		}
	}
	return -1
}

// IndexByte 按字节遍历返回指定Byte字节在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
func (b *Buffer) IndexByte(v byte) int {
	if len(b.buf) == 0 {
		return -1
	}
	return bytes.IndexByte(b.buf, v)
}

// IndexRune 按字节遍历返回指定Rune字符在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
func (b *Buffer) IndexRune(v rune) int {
	if len(b.buf) == 0 {
		return -1
	}
	return bytes.IndexRune(b.buf, v)
}

// LastIndex 按字节遍历返回指定字节切片[]byte在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
//   - 注意: subBytes 为空返回 -1
func (b *Buffer) LastIndex(subBytes []byte) int {
	if len(subBytes) == 0 {
		return -1
	}
	if len(b.buf) == 0 {
		return -1
	}
	if len(subBytes) == 1 {
		return b.LastIndexByte(subBytes[0])
	}
	return bytes.LastIndex(b.buf, subBytes)
}

// LastIndexString 返回指定字符串subString在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
//   - 注意: subString 为空返回 -1
func (b *Buffer) LastIndexString(subString string) int {
	if len(subString) == 0 {
		return -1
	}
	if len(b.buf) == 0 {
		return -1
	}
	subBytes := ToBytes(subString)
	if len(subBytes) == 1 {
		return b.LastIndexByte(subBytes[0])
	}
	return bytes.LastIndex(b.buf, subBytes)
}

// LastIndexByte 按字节遍历返回指定Byte字节在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
func (b *Buffer) LastIndexByte(v byte) int {
	if len(b.buf) == 0 {
		return -1
	}
	return bytes.LastIndexByte(b.buf, v)
}

// LastIndexRune 按Rune遍历返回指定Rune字符在 Stringer Buffer 中的字节POS位置
//   - 返回-1 表示未找到
func (b *Buffer) LastIndexRune(v rune) int {
	if len(b.buf) == 0 {
		return -1
	}
	return bytes.LastIndex(b.buf, []byte(string(v)))
}

// Trim 清除首尾指定的字符(指定的字符串会进行遍历Trim)
func (b *Buffer) Trim(cutset string) *Buffer {
	if len(b.buf) == 0 || cutset == "" {
		return b
	}
	b.buf = bytes.Trim(b.buf, cutset)
	b.onlyASCII = -1
	return b
}

// TrimSpace 去除首尾空字符
func (b *Buffer) TrimSpace() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	b.buf = bytes.TrimSpace(b.buf)
	return b
}

// TrimPrefix 去除前缀字节切片[]byte
func (b *Buffer) TrimPrefix(cutset []byte) *Buffer {
	if len(b.buf) == 0 || len(cutset) == 0 {
		return b
	}
	b.buf = bytes.TrimPrefix(b.buf, cutset)
	return b
}

// TrimSuffix 去除后缀字节切片[]byte
func (b *Buffer) TrimSuffix(cutset []byte) *Buffer {
	if len(b.buf) == 0 || len(cutset) == 0 {
		return b
	}
	b.buf = bytes.TrimSuffix(b.buf, cutset)
	return b
}

// TrimPrefixString 去除前缀字符串
func (b *Buffer) TrimPrefixString(cutset string) *Buffer {
	if len(b.buf) == 0 || cutset == "" {
		return b
	}
	b.buf = bytes.TrimPrefix(b.buf, []byte(cutset))
	return b
}

// TrimSuffixString 去除后缀字符
func (b *Buffer) TrimSuffixString(cutset string) *Buffer {
	if len(b.buf) == 0 || cutset == "" {
		return b
	}
	b.buf = bytes.TrimSuffix(b.buf, []byte(cutset))
	return b
}

// TrimLeft 去除左侧字符
func (b *Buffer) TrimLeft(cutset string) *Buffer {
	if len(b.buf) == 0 || cutset == "" {
		return b
	}
	b.buf = bytes.TrimLeft(b.buf, cutset)
	return b
}

// TrimRight 去除右侧字符
func (b *Buffer) TrimRight(cutset string) *Buffer {
	if len(b.buf) == 0 || cutset == "" {
		return b
	}
	b.buf = bytes.TrimRight(b.buf, cutset)
	return b
}

// Replace 替换指定字节切片[]byte为指定字节切片[]byte
//   - 注意: old 为空不进行任何操作
//   - 注意: n == -1 时表示全部替换
func (b *Buffer) Replace(old, new []byte, n int) *Buffer {
	if len(b.buf) == 0 || len(old) == 0 {
		return b
	}
	b.buf = bytes.Replace(b.buf, old, new, n)
	b.onlyASCII = -1
	return b
}

// ReplaceString 替换指定字符串为指定字符串
//   - 注意: old 为空不进行任何操作
//   - 注意: n == -1 时表示全部替换
func (b *Buffer) ReplaceString(old, new string, n int) *Buffer {
	if len(b.buf) == 0 || len(old) == 0 {
		return b
	}
	b.buf = bytes.Replace(b.buf, ToBytes(old), ToBytes(new), n)
	b.onlyASCII = -1
	return b
}

// ReplaceAll 替换指定字节切片[]byte为指定字节切片[]byte
//   - 注意: old 为空不进行任何操作
func (b *Buffer) ReplaceAll(old, new []byte) *Buffer {
	if len(b.buf) == 0 || len(old) == 0 {
		return b
	}
	b.buf = bytes.Replace(b.buf, old, new, -1)
	b.onlyASCII = -1
	return b
}

// ReplaceAllString 替换指定字符串为指定字符串
//   - 注意: old 为空不进行任何操作
func (b *Buffer) ReplaceAllString(old, new string) *Buffer {
	if len(b.buf) == 0 || len(old) == 0 {
		return b
	}
	b.buf = bytes.Replace(b.buf, ToBytes(old), ToBytes(new), -1)
	b.onlyASCII = -1
	return b
}

// InsertAt 在指定POS位置之后插入字节切片[]byte
//   - index 索引位置, 每一个字符(无论是ASCII或UTF-8多字节字符)均算做一位index索引
//   - 如果 pos <= 0, 则插入到开头
//   - 如果 pos >= len(Buffer), 则插入到结尾
func (b *Buffer) InsertAt(val []byte, index int) *Buffer {
	vLen := len(val)
	if vLen == 0 {
		return b
	}
	bLen := len(b.buf)
	// 如果 b.buf为空, 则直接插入
	// 如果 pos >= len(Buffer), 则直接插入
	if bLen == 0 || index >= bLen {
		b.Write(val)
		return b
	}
	// 如果pos <= 0, 则插入到开头
	if index <= 0 {
		nbuf := make([]byte, 0, max(bLen+vLen, b.Cap()))
		b.buf = append(append(nbuf, val...), b.buf...)
		b.onlyASCII = -1
		return b
	}
	// 插入到中间
	if b.OnlyASCII() {
		// 原Buf不含有ASCII字符
		nbuf := make([]byte, 0, max(bLen+vLen, b.Cap()))
		nbuf = append(nbuf, b.buf[:index]...)
		nbuf = append(nbuf, val...)
		b.buf = append(nbuf, b.buf[index:]...)
	} else {
		// 原Buf含有非ASCII字符
		bString := b.String()
		b.buf = make([]byte, 0, max(bLen+vLen, b.Cap()))
		i := 0 // range string, index 不是递增index(而是字符pos, 对于多字节的UTF-8可能递增2或3或4), 所以设置i
		for _, rune := range bString {
			if i == index {
				b.Write(val)
			}
			b.WriteRune(rune)
			i++
		}
	}
	b.onlyASCII = -1
	return b
}

// InsertStringAt 在指定POS位置之后插入字符串
//   - Pos 索引位置, 每一个字符(无论是ASCII或UTF-8多字节字符)均算做一位POS索引
//   - 如果 pos <= 0, 则插入到开头
//   - 如果 pos >= len(Buffer)-1, 则插入到结尾
func (b *Buffer) InsertStringAt(val string, index int) *Buffer {
	if len(val) == 0 {
		return b
	}
	return b.InsertAt(internal.StringToBytes(val), index)
}

// ToLower 转换为小写
func (b *Buffer) ToLower() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	for i := 0; i < len(b.buf); i++ {
		if b.buf[i] >= 'A' && b.buf[i] <= 'Z' {
			b.buf[i] += 32
		}
	}
	return b
}

// ToUpper 转换为大写
func (b *Buffer) ToUpper() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	for i := 0; i < len(b.buf); i++ {
		if b.buf[i] >= 'a' && b.buf[i] <= 'z' {
			b.buf[i] -= 32
		}
	}
	return b
}

// ToSBC 将全角字符转为半角
func (b *Buffer) ToSBC() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	b.buf = width.Narrow.Bytes(b.buf)
	return b
}

// ToDBC 将半角字符转为全角
func (b *Buffer) ToDBC() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	b.buf = width.Widen.Bytes(b.buf)
	return b
}

// UcFirst 把字符串中的首字符转换为大写
func (b *Buffer) UcFirst() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	if b.OnlyASCII() {
		if b.buf[0] >= 'a' && b.buf[0] <= 'z' {
			b.buf[0] -= 32
		}
		return b
	}
	firstRune, size := utf8.DecodeRune(b.buf)
	if firstRune == utf8.RuneError || size == 0 {
		return b
	}
	toRune := unicode.ToUpper(firstRune)
	if toRune == firstRune {
		return b
	}
	var buf bytes.Buffer
	buf.WriteRune(toRune)
	buf.Write(b.buf[size:])
	b.buf = buf.Bytes()
	return b
}

// LcFirst 把字符串中的首字符转换为小写
func (b *Buffer) LcFirst() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	if b.OnlyASCII() {
		if b.buf[0] >= 'A' && b.buf[0] <= 'Z' {
			b.buf[0] += 32
		}
		return b
	}
	firstRune, size := utf8.DecodeRune(b.buf)
	if firstRune == utf8.RuneError || size == 0 {
		return b
	}
	toRune := unicode.ToLower(firstRune)
	if toRune == firstRune {
		return b
	}
	var buf bytes.Buffer
	buf.WriteRune(toRune)
	buf.Write(b.buf[size:])
	b.buf = buf.Bytes()
	return b
}

// UcWords 把字符串中每个单词的首字符转换为大写
func (b *Buffer) UcWords() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	b.buf = cases.Title(language.English).Bytes(b.buf)
	return b
}

// Reverse 全部字符反序
func (b *Buffer) Reverse() *Buffer {
	if len(b.buf) == 0 {
		return b
	}
	if b.OnlyASCII() {
		buf := slices.Clone(b.buf)
		for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
			buf[i], buf[j] = buf[j], buf[i]
		}
		b.buf = buf
		return b
	}
	runes := internal.BytesToRunes(b.buf)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	b.Reset()
	for i := 0; i < len(runes); i++ {
		b.WriteRune(runes[i])
	}
	return b
}

// Clone 复制一个 Stringer Buffer
func (b *Buffer) Clone() *Buffer {
	if len(b.buf) == 0 {
		return NewBuffer()
	}
	n := NewBuffer(b.Cap())
	n.buf = append([]byte{}, b.buf...)
	n.onlyASCII = b.onlyASCII
	return n
}

// MapByte 按字节遍历回调处理 Stringer Buffer
func (b *Buffer) MapByte(mapping func(val byte) (newVal byte, isBreak bool)) {
	bufUpdate := false
	for i := 0; i < len(b.buf); i++ {
		n, is := mapping(b.buf[i])
		if n != b.buf[i] {
			b.buf[i] = n
			bufUpdate = true
		}
		if is {
			break
		}
	}
	if bufUpdate {
		b.onlyASCII = -1
	}
}

// MapRune 按Rune字符遍历回调处理 Stringer Buffer
func (b *Buffer) MapRune(mapping func(val rune) (newVal rune, isBreak bool)) {
	bufRunes := internal.BytesToRunes(b.buf)
	bufUpdate := false
	for i := 0; i < len(bufRunes); i++ {
		n, is := mapping(bufRunes[i])
		if n != bufRunes[i] {
			bufRunes[i] = n
			bufUpdate = true
		}
		if is {
			break
		}
	}
	if bufUpdate {
		b.buf = internal.RunesToBytes(bufRunes)
		b.onlyASCII = -1
	}
}

// IterBytes 按字节遍历方式的迭代器
//   - for k,v:=range s.IterBytes(){}
func (b *Buffer) IterBytes() iter.Seq[byte] {
	return func(yield func(val byte) bool) {
		for i := 0; i < len(b.buf); i++ {
			if !yield(b.buf[i]) {
				return
			}
		}
	}
}

// IterRunes 按Rune字符遍历方式的迭代器
//   - for v:=range s.IterRunes(){}
func (b *Buffer) IterRunes() iter.Seq[rune] {
	return func(yield func(val rune) bool) {
		for _, r := range b.String() {
			if !yield(r) {
				return
			}
		}
	}
}

// String 返回字符串 Stringer 接口实现
func (b *Buffer) String() string {
	if len(b.buf) == 0 {
		return ""
	}
	return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))
}

// Bytes 返回Stringer Buffer Byte切片
func (b *Buffer) Bytes() []byte {
	if len(b.buf) == 0 {
		return []byte{}
	}
	bytes := make([]byte, 0, len(b.buf))
	bytes = append(bytes, b.buf...)
	return bytes
}

// Runes 返回Stringer Buffer Rune切片
func (b *Buffer) Runes() []rune {
	if len(b.buf) == 0 {
		return []rune{}
	}
	return internal.BytesToRunes(b.buf)
}

// BytesAndSplit 返回分割后的 Byte切片组
func (b *Buffer) BytesAndSplit(sep []byte) (sepSlice [][]byte) {
	if len(b.buf) == 0 {
		return [][]byte{}
	}
	return bytes.Split(b.Bytes(), sep)
}

// StringAndSplit 返回分割后的 String切片组
func (b *Buffer) StringAndSplit(sep string) (sepSlice []string) {
	if len(b.buf) == 0 {
		return []string{}
	}
	sepBytes := bytes.Split(b.buf, internal.StringToBytes(sep))
	sepSlice = make([]string, len(sepBytes))
	for i, s := range sepBytes {
		sepSlice[i] = unsafe.String(unsafe.SliceData(s), len(s))
	}
	return sepSlice
}

// RunesAndSplit 返回分割后的 Rune切片组
func (b *Buffer) RunesAndSplit(sep rune) (sepSlice [][]rune) {
	if len(b.buf) == 0 {
		return [][]rune{}
	}
	sepBytes := bytes.Split(b.buf, internal.OneRuneToBytes(sep))
	sepSlice = make([][]rune, len(sepBytes))
	for i, s := range sepBytes {
		sepSlice[i] = internal.BytesToRunes(s)
	}
	return sepSlice
}

// MarshalJSON 序列化集合接口
func (b *Buffer) MarshalJSON() ([]byte, error) {
	if len(b.buf) == 0 {
		return []byte{}, nil
	}
	return b.buf, nil
}

// UnmarshalJSON 反序列化集合接口
func (b *Buffer) UnmarshalJSON(data []byte) error {
	b.Reset()
	b.Write(data)
	return nil
}
